﻿#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
using namespace std;

//如何实现一个不能被继承的类
//C++98 私有化父类的构造函数
//class A {
//public:
//private:
//	A() {}
//	//父类私有化构造函数，子类无法创建对象
//	//因为继承以后不可见(子类的里面外面都不能访问)
//protected:
//	int _a;
//	int _b;
//};
//
//class B : public A {
//};



//C++11新增final修饰父类，直接不能被继承
//class A final {
//public:
//	A() {}
//private:
//	int _a;
//	int _b;
//};
//
//class B : public A {
//};



//5.继承与友元
//友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员
//class Student;
//class Person {
//public:
//	friend void Display(const Person& p, const Student& s);
//protected:
//	string _name;
//};
//
//class Student : public Person {
//protected:
//	int _stuNum;
//};
//
//void Display(const Person& p, const Student& s) {
//	cout << p._name << endl;
//	cout << s._stuNum << endl;
//}



//6. 继承与静态成员
//基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。
//无论派生出多少个子类，都只有一个static成员实例 。
//class Person {
//public:
//	Person() { ++_count; }
//protected:
//	string _name;
//public:
//	static int _count;//统计人的个数。
//};
//int Person::_count = 0;
////静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
////静态成员也是类的成员，受public、protected、private 访问限定符的限制
//
//class Student : public Person {
//protected:
//	int _stuNum;
//};



//7.复杂的菱形继承及菱形虚拟继承
//class Person {
//public:
//	string _name;//姓名
//	int _age;
//};
//
//class Student : public Person {
//protected:
//	int _num;//学号
//};
//
//class Teacher : public Person {
//protected:
//	int _id;//职工编号
//};
//
//class Assistant : public Student, public Teacher {
//protected:
//	string _majorCourse;//主修课程
//};
//
//void Test() {
//	//菱形继承的问题：菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份。	
//	Assistant a;	
//	//a._name = "peter";//这样会有二义性无法明确知道访问的是哪一个
//
//	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
//	a.Student::_name = "xxx";
//	a.Teacher::_name = "yyy";
//}

//虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher继承
//Person时使用虚拟继承(即virtual关键字)，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。
//class Person {
//public:
//	string _name;
//};
//
//class Student : virtual public Person {
//protected:
//	int _num;
//};
//
//class Teacher : virtual public Person {
//protected:
//	int _id;
//};
//
//class Assistant : public Student, public Teacher {
//protected:
//	string _majorCourse;
//};
//
//void Test() {
//	Assistant a;
//	//即可指定访问，也能不指定访问
//	a.Student::_name = "xxx";
//	a.Teacher::_name = "yyy";
//	a._name = "peter";
//}



//虚拟继承解决数据冗余和二义性的原理
//为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成员的模型。
//非虚拟继承时D的情况演示
//class A {
//public:
//	int _a;
//};
//
//class B : public A {
////class B : virtual public A {
//public:
//	int _b;
//};
//
//class C : public A {
////class C : virtual public A {
//public:
//	int _c;
//};
//
//class D : public B, public C {
//public:
//	int _d;
//};
//
//int main() {
//	//A：_a
//	//B：_a, _b
//	//C：_a, _c
//	//D：B::_a, _b,  C::_a, _c,  _d
//	D d;
//	d.B::_a = 1;
//	d.C::_a = 2;
//	d._b = 3;
//	d._c = 4;
//	d._d = 5;
//	return 0;
//}

//虚拟继承时，D的情况演示
//class A {
//public:
//	int _a;
//};
//
//class B : virtual public A {
//public:
//	int _b;
//};
//
//class C : virtual public A {
//public:
//	int _c;
//};
//
//class D : public B, public C {
//public:
//	int _d;
//};
//
//int main() {
//	D d;
//	d._a = 1;
//	d._b = 2;
//
//	B b = d;
//	b._a = 1;
//	b._b = 2;
//	return 0;
//}
//D对象中将A放到了对象组成的最下面，这个A同时属于B和C，
//那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。
//这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。



//继承和组合
//public继承是一种is - a的关系。也就是说每个派生类对象都是一个基类对象。
//组合是一种has - a的关系。假设B组合了A，每个B对象中都有一个A对象。

//继承
class A {
public:
	void func() {}
protected:
	int _a;
};

class B : public A {
public:
	void f() {
		func();//父类的公有可以使用
		_a++;//父类的保护也可以使用
	}
protected:
	int _b;
};


//组合
class C {
public:
	void func() {}
protected:
	int _c;
};

class D {
public:
	void f() {
		cc.func();//组合类的公有可以使用
		//cc._c++;//组合类的保护不可以使用
	}
protected:
	C cc;
	int _d;
};

int main() {
	cout << sizeof(B) << endl;//8
	cout << sizeof(D) << endl;//8

	D dd;
	//dd.func();//组合：dd对象不能直接调用func

	B bb;
	bb.func();//继承：bb对象可以直接调用
	return 0;
}